package es.tikitaka.actions.competicion;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import org.jboss.seam.ScopeType;
import org.jboss.seam.annotations.Begin;
import org.jboss.seam.annotations.End;
import org.jboss.seam.annotations.In;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.faces.FacesMessages;

import es.tikitaka.dao.AniosDicService;
import es.tikitaka.dao.CalendarioLigaService;
import es.tikitaka.dao.ColegiadoService;
import es.tikitaka.dao.ComiteService;
import es.tikitaka.dao.EqMantenimientoService;
import es.tikitaka.dao.EquipoService;
import es.tikitaka.dao.EstColegiadoService;
import es.tikitaka.dao.EstEquipoService;
import es.tikitaka.dao.EstJornadaService;
import es.tikitaka.dao.EstJugadorService;
import es.tikitaka.dao.JornadaService;
import es.tikitaka.dao.JugadorService;
import es.tikitaka.dao.LigaService;
import es.tikitaka.dao.PartColegiadoService;
import es.tikitaka.dao.PartEquipoService;
import es.tikitaka.dao.PartJugadorService;
import es.tikitaka.dao.PartidoLService;
import es.tikitaka.dao.PlayoffsService;
import es.tikitaka.dao.SegColegiadoService;
import es.tikitaka.dao.SegEquipoService;
import es.tikitaka.dao.SegJugadorService;
import es.tikitaka.dao.TemporadaService;
import es.tikitaka.dictionary.AniosDic;
import es.tikitaka.domain.Temporada;
import es.tikitaka.domain.colegiado.Colegiado;
import es.tikitaka.domain.colegiado.EstColegiado;
import es.tikitaka.domain.colegiado.PartColegiado;
import es.tikitaka.domain.equipo.Equipo;
import es.tikitaka.domain.equipo.EstEquipo;
import es.tikitaka.domain.equipo.PartEquipo;
import es.tikitaka.domain.equipo.SegEquipo;
import es.tikitaka.domain.jugador.EstJugador;
import es.tikitaka.domain.jugador.Jugador;
import es.tikitaka.domain.jugador.PartJugador;
import es.tikitaka.domain.jugador.SegJugador;
import es.tikitaka.domain.liga.Jornada;
import es.tikitaka.domain.liga.Liga;
import es.tikitaka.domain.liga.PartidoL;
import es.tikitaka.domain.playoffs.Playoffs;

/**
 * 
 * @author Saúl Domínguez
 * @since 2010
 * @category PFC
 */

@Name("competicionAction")
@Scope(ScopeType.CONVERSATION)
public class CompeticionAction {

	private int modo;
	private boolean nuevo;

	private AniosDic anio;

	private Temporada temporada;
	private Temporada temporadaEdicion;
	private Temporada temporadaConsulta;
	private Temporada newTemporada;

	private String buscarEq;
	private String buscarCol;
	private int buscarColEn;
	private String buscarJug;
	private int buscarJugEn;
	private boolean guardado = false;

	private List<AniosDic> listaAnios;
	private List<Temporada> listaTemporadas;
	private List<Temporada> listaTemporadasCalendario;

	private List<Equipo> listaEquiposBus;
	private List<Equipo> listaEquiposSel;

	private List<Jugador> listaJugadoresBus;
	private List<Jugador> listaJugadoresSel;

	private List<Colegiado> listaColegiadosBus;
	private List<Colegiado> listaColegiadosSel;

	@In(create = true)
	private AniosDicService aniosService;

	@In(create = true)
	private EquipoService equipoService;

	@In(create = true)
	private PartEquipoService partEquipoService;

	@In(create = true)
	private EstEquipoService estEquipoService;

	@In(create = true)
	private SegEquipoService segEquipoService;

	@In(create = true)
	private JugadorService jugadorService;

	@In(create = true)
	private PartJugadorService partJugadorService;

	@In(create = true)
	private EstJugadorService estJugadorService;

	@In(create = true)
	private SegJugadorService segJugadorService;

	@In(create = true)
	private ColegiadoService colegiadoService;

	@In(create = true)
	private PartColegiadoService partColegiadoService;

	@In(create = true)
	private EstColegiadoService estColegiadoService;

	@In(create = true)
	private SegColegiadoService segColegiadoService;

	@In(create = true)
	private TemporadaService temporadaService;

	@In(create = true)
	private LigaService ligaService;

	@In(create = true)
	private CalendarioLigaService calendarioLigaService;

	@In(create = true)
	private JornadaService jornadaService;

	@In(create = true)
	private PartidoLService partidoLService;

	@In(create = true)
	private EstJornadaService estJornadaService;

	@In(create = true)
	private PlayoffsService playoffsService;

	@In(create = true)
	private ComiteService comiteService;

	@In(create = true)
	private EqMantenimientoService eqMantenimientoService;

	/**
	 * Constructor por defecto
	 */
	public CompeticionAction() {
		// TODO Auto-generated constructor stub
	}

	/**
	 * Mñetodo para la creación de una nueva temporada
	 */
	public void nuevaTemporada() {
		newTemporada = new Temporada();
		listaAnios = aniosService.getList();
		Liga liga = new Liga();
		Playoffs playoffs = new Playoffs();
		newTemporada.setLiga(liga);
		newTemporada.setPlayoffs(playoffs);
	}

	public void cargaOpciones() {
		listaTemporadas = temporadaService.getList();
		listaTemporadasCalendario = temporadaService.getTemporadasCalendario();
	}

	@Begin(join = true)
	public void editar() {
		if (temporadaEdicion != null) {
			this.temporada = temporadaEdicion;
			if (temporada.getM_equipos() == null) {
				temporada.setM_equipos(new HashSet<PartEquipo>());
			} else {
				if (listaEquiposSel == null) {
					listaEquiposSel = new ArrayList<Equipo>();
				}
				for (PartEquipo p : temporada.getM_equipos()) {
					listaEquiposSel.add(p.getEquipo());
				}
			}
			if (temporada.getM_jugadores() == null) {
				temporada.setM_jugadores(new HashSet<PartJugador>());
			} else {
				if (listaJugadoresSel == null) {
					listaJugadoresSel = new ArrayList<Jugador>();
				}
				for (PartJugador p : temporada.getM_jugadores()) {
					listaJugadoresSel.add(p.getJugador());
				}
			}
			if (temporada.getM_colegiados() == null) {
				temporada.setM_colegiados(new HashSet<PartColegiado>());
			} else {
				if (listaColegiadosSel == null) {
					listaColegiadosSel = new ArrayList<Colegiado>();
				}
				for (PartColegiado p : temporada.getM_colegiados()) {
					listaColegiadosSel.add(p.getColegiado());
				}
			}
		}
	}

	/**
	 * Método para buscar equipos que incluir en la temporada
	 */
	public void buscarEquipos() {
		if (!(buscarEq != null && buscarEq.length() > 0)) {
			buscarEq = "";
		}

		listaEquiposBus = equipoService.buscarActivosSinTemporada(buscarEq,
				temporada);
	}

	/**
	 * Método para buscar jugadores que incluir en la temporada
	 */
	public void buscarJugadores() {
		if (!(buscarJug != null && buscarJug.length() > 0)) {
			buscarJug = "";
		}

		listaJugadoresBus = jugadorService.buscarActivosSinTemporada(buscarJug,
				buscarJugEn, temporada);
	}

	/**
	 * Método para buscar colegiados que incluir en la temporada
	 */
	public void buscarColegiados() {
		if (!(buscarCol != null && buscarCol.length() > 0)) {
			buscarCol = "";
		}

		listaColegiadosBus = colegiadoService.buscarActivosSinTemporada(
				buscarCol, buscarColEn, temporada);
	}

	/**
	 * Método para dar de alta una temporada en el sistema
	 */
	@Begin(join = true)
	public void altaTemporada() {

		if (comprobarAnio()) {
			if (ligaService.save(newTemporada.getLiga())) {
				if (playoffsService.save(newTemporada.getPlayoffs())) {
					newTemporada.setAnio(anio);
					if (temporadaService.save(newTemporada)) {
						FacesMessages.instance().add(
								"Se ha creado la nueva temporada con éxito");
					} else {
						FacesMessages.instance().add(
								"Error al generar la temporada.");
					}
				} else {
					FacesMessages
							.instance()
							.add(
									"Error al guardar los playoffs asociados a la temporada.");
				}
			} else {
				FacesMessages.instance().add(
						"Error al guardar la liga asociada a la temporada.");
			}
		}
	}

	/**
	 * Método para dar de baja una temporada en el sistema
	 */
	public void bajaTemporada() {
		if (!comprobarInicioTemporada(temporada)) {
			// La temporada no se ha iniciado aún, por lo que puede ser dada de
			// baja
			// comprobamos si existe un calendario de liga
			boolean exCal = false;
			if (temporada.getLiga().getCalendario() != null) {
				// en caso de que exista y editemos los equipos, el calendario
				// se deberá eliminar y todos los seguimientos
				exCal = true;
			}
			if (exCal) {
				// Como existe calendario hay que borrar los seguimientos, los
				// partidos, las estadísticas de las jornadas, las jornadas y el
				// calendario
				eliminarCalendario(temporada);
			}
			// Ahora se borran las estadísticas de las participaciones, las
			// participaciones, la liga y los playoofs y por último la temporada
			// en sí
			for (PartJugador pj : temporada.getM_jugadores()) {
				if (pj.getEstadisticas() != null) {
					estJugadorService.delete(pj.getEstadisticas().getId());
				}
				partJugadorService.delete(pj.getId());
			}
			for (PartEquipo pe : temporada.getM_equipos()) {
				if (pe.getEstadisticas() != null) {
					estEquipoService.delete(pe.getEstadisticas().getId());
				}
				partEquipoService.delete(pe.getId());
			}
			for (PartColegiado pc : temporada.getM_colegiados()) {
				if (pc.getEstadisticas() != null) {
					estColegiadoService.delete(pc.getEstadisticas().getId());
				}
				partColegiadoService.delete(pc.getId());
			}
			ligaService.delete(temporada.getLiga().getId());
			temporadaService.delete(temporada.getId());
			FacesMessages
					.instance()
					.add(
							"Temporada dada de baja con éxito.");
		}
	}

	/**
	 * Método para comprobar la existencia de una temporada en el año
	 * seleccionado
	 * 
	 * @return estado de la comprobación
	 */
	public boolean comprobarAnio() {
		boolean estado = false;
		if (anio != null) {
			estado = temporadaService.existeTemporada(anio);

			if (estado) {
				FacesMessages
						.instance()
						.add(
								"Ya existe una temporada en el sistema para el año seleccionado.");
			}

		} else {
			FacesMessages
					.instance()
					.add(
							"Debe seleccionar un año para dar de alta una nueva temporada.");
		}
		return !estado;
	}

	public void guardar() {
		if (!comprobarInicioTemporada(temporada)) {
			// comprobamos si existe un calendario de liga
			boolean exCal = false;
			if (temporada.getLiga().getCalendario() != null) {
				// en caso de que exista y editemos los equipos, el calendario
				// se deberá eliminar y todos los seguimientos
				exCal = true;
			}
			if (listaEquiposSel != null && listaEquiposSel.size() > 0) {
				List<Equipo> equipos = new ArrayList<Equipo>();
				for (PartEquipo e : temporada.getM_equipos()) {
					equipos.add(e.getEquipo());
				}
				for (Equipo e : listaEquiposSel) {
					equipos.remove(e);
				}
				if (equipos != null) {
					// Hay que eliminar la participación del equipo para la
					// temporada en cuestion, sus estadísticas y todos sus
					// seguimientos
					for (Equipo eq : equipos) {
						for (PartEquipo p : eq.getM_participaciones()) {
							if (p.getTemporada().equals(temporada)) {
								// Se han eliminado equipos
								// se debe comprobar el calendario para
								// eliminarlo en caso de que exista
								if (exCal) {
									eliminarCalendario(temporada);
									exCal = false;
								}
								estEquipoService.delete(p.getEstadisticas()
										.getId());
								partEquipoService.delete(p.getId());
							}
						}
					}
				}
				if (altaParticipacionesEquipos(listaEquiposSel)) {
					FacesMessages
							.instance()
							.add(
									"Equipos dados de alta en la competición con éxito.");
				}
			}
			if (listaEquiposSel.size() == 0) {
				// No hay ningún equipo participante en la temporada
				// En caso de que con aterioridad lo hubiese, hay que borrar sus
				// participaciones, sus estadísticas y todos sus seguimientos
				if (temporada.getM_equipos() != null
						&& temporada.getM_equipos().size() > 0) {
					for (PartEquipo p : temporada.getM_equipos()) {
						estEquipoService.delete(p.getEstadisticas().getId());
						partEquipoService.delete(p.getId());
					}
				}
			}
			if (listaJugadoresSel != null && listaJugadoresSel.size() > 0) {
				List<Jugador> jugadores = new ArrayList<Jugador>();
				for (PartJugador j : temporada.getM_jugadores()) {
					jugadores.add(j.getJugador());
				}
				for (Jugador j : listaJugadoresSel) {
					jugadores.remove(j);
				}
				if (jugadores != null) {
					// Hay que eliminar la participación del jugador para la
					// temporada en cuestion, sus estadísticas y todos sus
					// seguimientos
					for (Jugador j : jugadores) {
						for (PartJugador p : j.getM_jugadores()) {
							if (p.getTemporada().equals(temporada)) {
								estJugadorService.delete(p.getEstadisticas()
										.getId());
								partJugadorService.delete(p.getId());
							}
						}
					}
				}
				if (altaParticipacionesJugadores(listaJugadoresSel)) {
					FacesMessages
							.instance()
							.add(
									"Jugadores dados de alta en la competición con éxito.");
				}
			}
			if (listaJugadoresSel.size() == 0) {
				// No hay ningún jugador participante en la temporada
				// En caso de que con aterioridad lo hubiese, hay que borrar sus
				// participaciones, sus estadisticas y todos sus seguimientos
				if (temporada.getM_jugadores() != null
						&& temporada.getM_jugadores().size() > 0) {
					for (PartJugador p : temporada.getM_jugadores()) {
						estJugadorService.delete(p.getEstadisticas().getId());
						partJugadorService.delete(p.getId());
					}
				}
			}
			if (listaColegiadosSel != null && listaColegiadosSel.size() > 0) {
				List<Colegiado> colegiados = new ArrayList<Colegiado>();
				for (PartColegiado c : temporada.getM_colegiados()) {
					colegiados.add(c.getColegiado());
				}
				for (Colegiado c : listaColegiadosSel) {
					colegiados.remove(c);
				}
				if (colegiados != null) {
					// Hay que eliminar la participación del jugador para la
					// temporada en cuestión, sus estadísticas y sus seguimiento
					for (Colegiado c : colegiados) {
						for (PartColegiado p : c.getM_participaciones()) {
							if (p.getTemporada().equals(temporada)) {
								estColegiadoService.delete(p.getEstadisticas()
										.getId());
								partColegiadoService.delete(p.getId());
							}
						}
					}
				}
				if (altaParticipacionesColegiados(listaColegiadosSel)) {
					FacesMessages
							.instance()
							.add(
									"Colegiados dados de alta en la competición con éxito.");
				}
			}
			if (listaColegiadosSel.size() == 0) {
				// No hay ningún jugador participante en la temporada
				// En caso de que con aterioridad lo hubiese, hay que borrar sus
				// participaciones, sus estadisticas y su seguimiento
				if (temporada.getM_colegiados() != null
						&& temporada.getM_colegiados().size() > 0) {
					for (PartColegiado p : temporada.getM_colegiados()) {
						estColegiadoService.delete(p.getEstadisticas().getId());
						partColegiadoService.delete(p.getId());
					}
				}
			}
		}
	}

	/**
	 * Método para comprobar si la temporada ha comenzado o no para ver si se
	 * puede editar sus datos
	 * 
	 * @param tempo
	 * @return
	 */
	private boolean comprobarInicioTemporada(Temporada tempo) {
		boolean comenzada = false;

		if (tempo.getLiga().getCalendario() != null) {
			List<Jornada> jornadas = new ArrayList<Jornada>();
			jornadas.addAll(tempo.getLiga().getCalendario().getM_jornadas());
			Collections.sort(jornadas);
			Iterator it = jornadas.get(0).getM_partidos().iterator();
			while (it.hasNext() && !comenzada) {
				PartidoL p = (PartidoL) it.next();
				if (p.getEstado().equals("comenzado") || p.isFin()) {
					comenzada = true;
				}
			}
		}

		return comenzada;
	}

	/**
	 * Método para eliminar el calendario de la temporada y todos los
	 * seguimientos
	 * 
	 * @param temporada2
	 */
	private void eliminarCalendario(Temporada tempo) {
		// Como existe calendario hay que borrar los seguimientos, los
		// partidos, las estadísticas de las jornadas, las jornadas y el
		// calendario
		List<Jornada> jornadas = new ArrayList<Jornada>();
		jornadas.addAll(tempo.getLiga().getCalendario().getM_jornadas());
		Collections.sort(jornadas);
		for (Jornada j : jornadas) {
			for (PartidoL p : j.getM_partidos()) {
				for (SegEquipo se : p.getM_equipos()) {
					for (SegJugador sj : se.getM_jugadores()) {
						segJugadorService.delete(sj.getId());
					}
					segEquipoService.delete(se.getId());
				}
				segColegiadoService.delete(p.getId());
				partidoLService.delete(p.getId());
			}
			estJornadaService.delete(j.getEstadisticas().getId());
			jornadaService.delete(j.getId());
		}
		calendarioLigaService.delete(temporada.getLiga().getCalendario()
				.getId());
	}

	/**
	 * Método para crear las participaciones de los equipos en la temporada que
	 * esá siendo dada de alta
	 * 
	 * @param participantes
	 *            Lista de equipos participantes en la temporada
	 * @return estado del proceso (true or false)
	 */
	public boolean altaParticipacionesEquipos(List<Equipo> participantes) {
		boolean exito = true;

		Iterator<Equipo> ite = participantes.iterator();
		while (ite.hasNext() && exito) {
			// recorro la lista de equipos participantes para ir creando las
			// participaciones para la temporada si no la tiene ya creada

			Equipo eq = (Equipo) ite.next();
			boolean existe = false;
			for (PartEquipo p : eq.getM_participaciones()) {
				if (p.getTemporada().equals(temporada)) {
					existe = true;
				}
			}
			if (!existe) {
				PartEquipo pe = new PartEquipo();
				EstEquipo est = new EstEquipo();
				pe.setEquipo(eq);
				pe.setTemporada(temporada);
				pe.setLiga(temporada.getLiga());
				pe.setEstadisticas(est);
				est.setEquipo(pe);

				if (eq.getM_participaciones() != null) {
					eq.getM_participaciones().add(pe);
				} else {
					HashSet<PartEquipo> m_par = new HashSet<PartEquipo>();
					m_par.add(pe);
					eq.setM_participaciones(m_par);
				}

				if (partEquipoService.save(pe)) {
					if (equipoService.save(eq)) {
						exito = true;
					} else {
						exito = false;
					}
				} else {
					exito = false;
				}
			}
		}
		return exito;
	}

	/**
	 * Método para crear las participaciones de los jugadores en la temporada
	 * que está siendo dada de alta
	 * 
	 * @param participantes
	 *            Lista de jugadores participantes en la temporada
	 * @return estado del proceso (true or false)
	 */
	public boolean altaParticipacionesJugadores(List<Jugador> participantes) {
		boolean exito = true;

		Iterator<Jugador> itj = participantes.iterator();
		while (itj.hasNext() && exito) {
			// recorro la lista de jugadores participantes para ir creando las
			// participaciones de la temporada

			Jugador jug = (Jugador) itj.next();
			boolean existe = false;
			for (PartJugador p : jug.getM_jugadores()) {
				if (p.getTemporada().equals(temporada)) {
					existe = true;
				}
			}
			if (!existe) {
				PartJugador pj = new PartJugador();
				EstJugador est = new EstJugador();
				pj.setJugador(jug);
				pj.setTemporada(temporada);
				pj.setEdad(calculaEdad(jug));
				pj.setEstadisticas(est);
				est.setJugador(pj);

				if (jug.getM_jugadores() != null) {
					jug.getM_jugadores().add(pj);
				} else {
					HashSet<PartJugador> m_par = new HashSet<PartJugador>();
					m_par.add(pj);
					jug.setM_jugadores(m_par);
				}

				if (partJugadorService.save(pj)) {
					if (jugadorService.save(jug)) {
						exito = true;
					} else {
						exito = false;
					}
				} else {
					exito = false;
				}
			}
		}
		return exito;
	}

	/**
	 * Método para crear las participaciones de los colegiados en la temporada
	 * que esté siendo dada de alta
	 * 
	 * @param participantes
	 *            Lista de colegiados participantes en la temporada
	 * @return estado del proceso (true or false)
	 */
	public boolean altaParticipacionesColegiados(List<Colegiado> participantes) {
		boolean exito = true;

		Iterator<Colegiado> itc = participantes.iterator();
		while (itc.hasNext() && exito) {
			// recorro la lista de colegiados participantes para in creando las
			// participaciones de la temporada

			Colegiado col = (Colegiado) itc.next();
			boolean existe = false;
			for (PartColegiado p : col.getM_participaciones()) {
				if (p.getTemporada().equals(temporada)) {
					existe = true;
				}
			}
			if (!existe) {
				PartColegiado pc = new PartColegiado();
				EstColegiado est = new EstColegiado();
				pc.setColegiado(col);
				pc.setTemporada(temporada);
				pc.setEstadisticas(est);
				est.setColegiado(pc);

				if (col.getM_participaciones() != null) {
					col.getM_participaciones().add(pc);
				} else {
					HashSet<PartColegiado> m_par = new HashSet<PartColegiado>();
					m_par.add(pc);
					col.setM_participaciones(m_par);
				}

				if (partColegiadoService.save(pc)) {
					if (colegiadoService.save(col)) {
						exito = true;
					} else {
						exito = false;
					}
				} else {
					exito = false;
				}
			}
		}
		return exito;
	}

	public int calculaEdad(Jugador jugador) {

		int edad;

		if (jugador.getFechaNac() != null) {
			Long fecNac = jugador.getFechaNac().getTime();
			Date d = new Date();
			Long hoy = d.getTime();

			Long dif = hoy - fecNac;

			long mili = 365 * 24 * 60 * 60;
			dif = dif / mili;
			dif = dif / 1000;

			edad = Long.valueOf(dif).intValue();

		} else {
			edad = 0;
		}

		return edad;
	}

	/**
	 * Método para inicializar los parámetros de construcción de una nueva
	 * temporada
	 */
	public void limpiar() {
		anio = null;
		buscarEq = null;
		buscarCol = null;
		buscarColEn = 1;
		buscarJug = null;
		buscarJugEn = 1;
		listaEquiposBus = null;
		listaEquiposSel = null;
		listaJugadoresBus = null;
		listaEquiposSel = null;
		listaColegiadosBus = null;
		listaColegiadosSel = null;
		temporada = null;
	}

	/**
	 * Método para inicializar todos los parámetros al volver al menú de
	 * competición
	 */
	public void volver() {
		if (temporada != null) {
			temporadaService.merge(temporada);
		}
		limpiar();
	}

	/**
	 * Método para inicializar todos los parámetros al volver al menú principal
	 */
	@End
	public void menu() {
		limpiar();
	}

	/*
	 * getters and setters
	 */

	/**
	 * 
	 * @return
	 */
	public int getModo() {
		return modo;
	}

	/**
	 * 
	 * @param modo
	 */
	public void setModo(int modo) {
		this.modo = modo;
	}

	/**
	 * 
	 * @return
	 */
	public boolean isNuevo() {
		return nuevo;
	}

	/**
	 * 
	 * @param nuevo
	 */
	public void setNuevo(boolean nuevo) {
		this.nuevo = nuevo;
	}

	/**
	 * 
	 * @return
	 */
	public AniosDic getAnio() {
		return anio;
	}

	/**
	 * 
	 * @param anio
	 */
	public void setAnio(AniosDic anio) {
		this.anio = anio;
	}

	/**
	 * 
	 * @return
	 */
	public Temporada getTemporada() {
		return temporada;
	}

	/**
	 * 
	 * @param temporada
	 */
	public void setTemporada(Temporada temporada) {
		this.temporada = temporada;
	}

	/**
	 * 
	 * @return
	 */
	public Temporada getTemporadaEdicion() {
		return temporadaEdicion;
	}

	/**
	 * 
	 * @param temporadaEdicion
	 */
	public void setTemporadaEdicion(Temporada temporadaEdicion) {
		this.temporadaEdicion = temporadaEdicion;
	}

	/**
	 * 
	 * @return
	 */
	public Temporada getTemporadaConsulta() {
		return temporadaConsulta;
	}

	/**
	 * 
	 * @param temporadaConsulta
	 */
	public void setTemporadaConsulta(Temporada temporadaConsulta) {
		this.temporadaConsulta = temporadaConsulta;
	}

	/**
	 * 
	 * @return
	 */
	public Temporada getNewTemporada() {
		return newTemporada;
	}

	/**
	 * 
	 * @param newTemporada
	 */
	public void setNewTemporada(Temporada newTemporada) {
		this.newTemporada = newTemporada;
	}

	/**
	 * 
	 * @return
	 */
	public String getBuscarEq() {
		return buscarEq;
	}

	/**
	 * 
	 * @param buscarEq
	 */
	public void setBuscarEq(String buscarEq) {
		this.buscarEq = buscarEq;
	}

	/**
	 * 
	 * @return
	 */
	public String getBuscarCol() {
		return buscarCol;
	}

	/**
	 * 
	 * @param buscarCol
	 */
	public void setBuscarCol(String buscarCol) {
		this.buscarCol = buscarCol;
	}

	/**
	 * 
	 * @return
	 */
	public int getBuscarColEn() {
		return buscarColEn;
	}

	/**
	 * 
	 * @param buscarColEn
	 */
	public void setBuscarColEn(int buscarColEn) {
		this.buscarColEn = buscarColEn;
	}

	/**
	 * 
	 * @return
	 */
	public boolean isGuardado() {
		return guardado;
	}

	/**
	 * 
	 * @param guardado
	 */
	public void setGuardado(boolean guardado) {
		this.guardado = guardado;
	}

	/**
	 * 
	 * @return
	 */
	public List<AniosDic> getListaAnios() {
		return listaAnios;
	}

	/**
	 * 
	 * @param listaAnios
	 */
	public void setListaAnios(List<AniosDic> listaAnios) {
		this.listaAnios = listaAnios;
	}

	/**
	 * 
	 * @return
	 */
	public List<Temporada> getListaTemporadas() {
		return listaTemporadas;
	}

	/**
	 * 
	 * @param listaTemporadas
	 */
	public void setListaTemporadas(List<Temporada> listaTemporadas) {
		this.listaTemporadas = listaTemporadas;
	}

	/**
	 * 
	 * @return
	 */
	public List<Temporada> getListaTemporadasCalendario() {
		return listaTemporadasCalendario;
	}

	/**
	 * 
	 * @param listaTemporadasCalendario
	 */
	public void setListaTemporadasCalendario(
			List<Temporada> listaTemporadasCalendario) {
		this.listaTemporadasCalendario = listaTemporadasCalendario;
	}

	/**
	 * 
	 * @return
	 */
	public List<Equipo> getListaEquiposBus() {
		return listaEquiposBus;
	}

	/**
	 * 
	 * @param listaEquiposBus
	 */
	public void setListaEquiposBus(List<Equipo> listaEquiposBus) {
		this.listaEquiposBus = listaEquiposBus;
	}

	/**
	 * 
	 * @return
	 */
	public List<Equipo> getListaEquiposSel() {
		return listaEquiposSel;
	}

	/**
	 * 
	 * @param listaEquiposSel
	 */
	public void setListaEquiposSel(List<Equipo> listaEquiposSel) {
		this.listaEquiposSel = listaEquiposSel;
	}

	/**
	 * 
	 * @return
	 */
	public List<Colegiado> getListaColegiadosBus() {
		return listaColegiadosBus;
	}

	/**
	 * 
	 * @param listaColegiadosBus
	 */
	public void setListaColegiadosBus(List<Colegiado> listaColegiadosBus) {
		this.listaColegiadosBus = listaColegiadosBus;
	}

	/**
	 * 
	 * @return
	 */
	public List<Colegiado> getListaColegiadosSel() {
		return listaColegiadosSel;
	}

	/**
	 * 
	 * @param listaColegiadosSel
	 */
	public void setListaColegiadosSel(List<Colegiado> listaColegiadosSel) {
		this.listaColegiadosSel = listaColegiadosSel;
	}

	/**
	 * 
	 * @return
	 */
	public String getBuscarJug() {
		return buscarJug;
	}

	/**
	 * 
	 * @param buscarJug
	 */
	public void setBuscarJug(String buscarJug) {
		this.buscarJug = buscarJug;
	}

	/**
	 * 
	 * @return
	 */
	public int getBuscarJugEn() {
		return buscarJugEn;
	}

	/**
	 * 
	 * @param buscarJugEn
	 */
	public void setBuscarJugEn(int buscarJugEn) {
		this.buscarJugEn = buscarJugEn;
	}

	/**
	 * 
	 * @return
	 */
	public List<Jugador> getListaJugadoresBus() {
		return listaJugadoresBus;
	}

	/**
	 * 
	 * @param listaJugadoresBus
	 */
	public void setListaJugadoresBus(List<Jugador> listaJugadoresBus) {
		this.listaJugadoresBus = listaJugadoresBus;
	}

	/**
	 * 
	 * @return
	 */
	public List<Jugador> getListaJugadoresSel() {
		return listaJugadoresSel;
	}

	/**
	 * 
	 * @param listaJugadoresSel
	 */
	public void setListaJugadoresSel(List<Jugador> listaJugadoresSel) {
		this.listaJugadoresSel = listaJugadoresSel;
	}

}
